home *** CD-ROM | disk | FTP | other *** search
/ Software Vault: The Gold Collection / Software Vault - The Gold Collection (American Databankers) (1993).ISO / cdr10 / ehp10.zip / CUR_WGET.C < prev    next >
C/C++ Source or Header  |  1993-06-19  |  47KB  |  1,102 lines
  1. /******************************************************************************
  2. *
  3. * Modul      : cur_wget.c
  4. *
  5. * Funktionen : getch (Zeichen ungepuffert von Tastatur lesen)
  6. *              edit_left (Cursor in Eingabe nach links)
  7. *              edit_right (Cursor in Eingabe nach rechts)
  8. *              edit_del (Zeichen in Eingabe löschen)
  9. *              wort_ende (Testen, ob Zeichen Worttrenner)
  10. *              edit_ctrlright (Cursor in Eingabe ein Wort nach rechts)
  11. *              edit_ctrlleft (Cursor in Eingabe ein Wort nach links)
  12. *              edit_home (Cursor an Eingabeanfang)
  13. *              edit_end (Cursor an Eingabeende)
  14. *              treat_edit_keys (Edit-Tasten behandeln)
  15. *              inp_out (Eingabe ausgeben)
  16. *              treat_backspace (Backspace beim Edieren behandeln)
  17. *              buf_insert (Ein Zeichen in Puffer einfügen)
  18. *              getch_cooked (Zeichen gepuffet einlesen)
  19. *              wgetch (Zeichen einlesen)
  20. *
  21. ******************************************************************************/
  22.  
  23. #include "curses.h"
  24. #include "keys.h"
  25. #undef getch()   /* Damit C-getch aufgerufen werden kann */
  26.  
  27. void inp_out(WINDOW*, short int**, char**, short int**);
  28.  
  29. extern short int *cur_to_poi();
  30. extern char rawflag,echoflag,nlflag;
  31.  
  32. char buffer[BUFF_SIZE+1],*p_in=buffer,*p_out=buffer; /* Zeichenpuffer für wgetch */
  33.  
  34. #ifdef OS2
  35. /******************************************************************************
  36. *
  37. * Funktion     : Zeichen ungepuffert von Tastatur lesen (getch)
  38. * --------------
  39. *
  40. * Parameter    : wait        :
  41. *                  Typ          : char
  42. *                  Wertebereich : TRUE, FALSE
  43. *                  Bedeutung    : Gibt an, ob auf das Eingabezeichen gewartet
  44. *                                 werden soll.
  45. *
  46. * Ergebnis     :
  47. *                  Typ          : short int
  48. *                  Wertebereich : Ein Tastaturcode, der OS/2-spezifisch sein kann
  49. *                                 Low-Byte=0 bedeutet Sondertaste (F, Ctrl-rechts o.ä.)
  50. *                                 oder "kein Zeichen vorhanden". In letzterem Fall
  51. *                                 ist der komplette Rückgabewert jedoch 0.
  52. *                  Bedeutung    : Das eingelesene Zeichen, oder 0, falls nicht
  53. *                                 auf ein Zeichen gewartet werden sollte (wait==FALSE)
  54. *                                 und kein Zeichen anlag.
  55. *
  56. * Beschreibung : Mittels des OS/2 Systemaufrufs KbdCharIn wird
  57. *                ein Zeichen von der Tastatur gelesen und decodiert.
  58. *                Wenn sich die Tastatur im Raw-Mode befindet, können
  59. *                auch <CTRL>-S und <CTRL>-C erkannt werden.
  60. *
  61. ******************************************************************************/
  62.  
  63. short int getch (char wait)
  64. {
  65.   struct CharInBuffer { unsigned  char ascii,
  66.                   scan_code,
  67.                   status,
  68.                   reserved;
  69.             short int shifts;
  70.             long  int time_stamp; } cib;
  71.  
  72.   KbdCharIn (&cib, (short) !wait, 0);
  73.   if (!wait) /* Wenn nicht gewartet werden sollte, dann prüfen, */
  74.     if (!(cib.status & 64)) /* ob ein Zeichen gelesen werden konnte. */
  75.       return 0;
  76.   if (cib.ascii == (unsigned char) 0xE0)
  77.      cib.ascii = 0;
  78.   if (cib.ascii != 0)
  79.     cib.scan_code = 0;
  80.   return (short int) cib.ascii + 256 * (short int) cib.scan_code;
  81. }
  82. #endif
  83.  
  84. /******************************************************************************
  85. *
  86. * Funktion     : Cursor in Eingabe nach links (edit_left)
  87. * --------------
  88. *
  89. * Parameter    : w           :
  90. *                  Typ          : WINDOW *
  91. *                  Wertebereich : Pointer auf WINDOW-Struktur
  92. *                  Bedeutung    : Fenster, in dem evtl. Cursor bewegt werden
  93. *                                 soll
  94. *
  95. *              : buff_first  :
  96. *                  Typ          : char **
  97. *                  Wertebereich : Doppelpointer auf Zeichen in buffer
  98. *                  Bedeutung    : Erstes sichtbares Zeichen in buffer
  99. *
  100. *              : buff_last   :
  101. *                  Typ          : char **
  102. *                  Wertebereich : Doppelpointer auf Zeichen in buffer
  103. *                  Bedeutung    : Letztes sichtbares Zeichen in buffer
  104. *
  105. *              : pos_first   :
  106. *                  Typ          : short int **
  107. *                  Wertebereich : Doppelpointer in Window-Image
  108. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  109. *                                 theoretisch das erste Zeichen der Eingabe
  110. *                                 stehen würde (kann kleiner als image sein)
  111. *
  112. *              : pos_last    :
  113. *                  Typ          : short int **
  114. *                  Wertebereich : Doppelpointer in Window-Image
  115. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  116. *                                 theoretisch das letzte Zeichen der Eingabe
  117. *                                 stehen würde (kann hinters image zeigen)
  118. *
  119. *              : pos_lasts   :
  120. *                  Typ          : short int **
  121. *                  Wertebereich : Doppelpointer in Window-Image
  122. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  123. *                                 das letzte sichtbare Zeichen der Eingabe
  124. *                                 steht.
  125. *
  126. *              : old_pos     :
  127. *                  Typ          : short int **
  128. *                  Wertebereich : Doppelpointer in Window-Image
  129. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, bis wo
  130. *                                 vor der letzten Ausgabe der Eingabe der
  131. *                                 Text auf dem Bildschirm ging.
  132. *
  133. * Beschreibung : Falls eingegebene Zeichen angezeigt werden (echo), so wird
  134. *                zunächst getestet, ob der Cursor noch eins nach links bewegt
  135. *                werden kann. Falls nein, wird gar nichts gemacht. Sonst wird
  136. *                der Zeiger in den Puffer dekrementiert. Ist man dadurch links
  137. *                oben aus dem Schirm gelaufen, so wird der korrekte Teil der
  138. *                Eingabe nochmal angezeigt und die nötigen Variablen werden
  139. *                angepasst (pos_first, pos_last etc.)
  140. *
  141. ******************************************************************************/
  142.  
  143. void edit_left(w,buff_first,buff_last,pos_first,pos_last,pos_lasts,old_pos)
  144. WINDOW *w;
  145. char   **buff_first,**buff_last;
  146. short int  **pos_first, **pos_last, **pos_lasts, **old_pos;
  147. {
  148.   int i,pos;
  149.  
  150.   if(p_in > buffer)
  151.   {
  152.     p_in--;
  153.     if(echoflag)
  154.     {
  155.       if(p_in < *buff_first)  /* Links vom ersten sichtbaren Zeichen ? */
  156.       {
  157.     (*pos_first)++;
  158.     (*pos_last)++;
  159.     (*buff_first)--;
  160.     inp_out(w,old_pos,buff_last,pos_lasts);
  161.     wrefresh(w);
  162.       }
  163.       else
  164.       {
  165.     cur_left(w,1);
  166.     place_cursor(w);
  167.       }
  168.     }
  169.   }
  170. }
  171.  
  172. /******************************************************************************
  173. *
  174. * Funktion     : Cursor in Eingabe nach rechts (edit_right)
  175. * --------------
  176. *
  177. * Parameter    : w           :
  178. *                  Typ          : WINDOW *
  179. *                  Wertebereich : Pointer auf WINDOW-Struktur
  180. *                  Bedeutung    : Fenster, in dem evtl. Cursor bewegt werden
  181. *                                 soll
  182. *
  183. *              : buff_first  :
  184. *                  Typ          : char **
  185. *                  Wertebereich : Doppelpointer auf Zeichen in buffer
  186. *                  Bedeutung    : Erstes sichtbares Zeichen in buffer
  187. *
  188. *              : buff_last   :
  189. *                  Typ          : char **
  190. *                  Wertebereich : Doppelpointer auf Zeichen in buffer
  191. *                  Bedeutung    : Letztes sichtbares Zeichen in buffer
  192. *
  193. *              : pos_first   :
  194. *                  Typ          : short int **
  195. *                  Wertebereich : Doppelpointer in Window-Image
  196. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  197. *                                 theoretisch das erste Zeichen der Eingabe
  198. *                                 stehen würde (kann kleiner als image sein)
  199. *
  200. *              : pos_firsts  :
  201. *                  Typ          : short int **
  202. *                  Wertebereich : Doppelpointer in Window-Image
  203. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  204. *                                 das letzte sichtbare Zeichen der Eingabe
  205. *                                 steht.
  206. *
  207. *              : pos_last    :
  208. *                  Typ          : short int **
  209. *                  Wertebereich : Doppelpointer in Window-Image
  210. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  211. *                                 theoretisch das letzte Zeichen der Eingabe
  212. *                                 stehen würde (kann hinters image zeigen)
  213. *
  214. *              : pos_lasts   :
  215. *                  Typ          : short int **
  216. *                  Wertebereich : Doppelpointer in Window-Image
  217. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  218. *                                 das letzte sichtbare Zeichen der Eingabe
  219. *                                 steht.
  220. *
  221. *              : old_pos     :
  222. *                  Typ          : short int **
  223. *                  Wertebereich : Doppelpointer in Window-Image
  224. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, bis wo
  225. *                                 vor der letzten Ausgabe der Eingabe der
  226. *                                 Text auf dem Bildschirm ging.
  227. *
  228. * Beschreibung : Es wird zunächst getestet, ob sich der Cursor nicht am Ende
  229. *                des bisher eingegebenen Strings befindet. Ist dem so, dann
  230. *                geschieht nichts. Sonst wird, falls echoflag gesetzt ist, der
  231. *                Cursor um 1 nach rechts bewegt. Anschliessend wird p_in
  232. *                angepasst. Wurde durch die Cursorbewegung gescrollt, wird
  233. *                die nächste Zeile der Eingabe angezeigt und die Variablen
  234. *                buff_first etc. angepasst.
  235. *
  236. ******************************************************************************/
  237.  
  238. void edit_right(w,buff_first,buff_last,pos_first,pos_firsts,pos_last,pos_lasts,old_pos)
  239. WINDOW *w;
  240. char   **buff_first,**buff_last;
  241. short int **pos_first, **pos_firsts, **pos_last, **pos_lasts, **old_pos;
  242. {
  243.   short int old_y;
  244.  
  245.   if(*p_in)  /* Geht nur, falls man nicht am Ende steht */
  246.   {
  247.     p_in++;
  248.     if(echoflag)
  249.     {
  250.       old_y = w->_cursor_y;
  251.       cur_right(w,1);   /* Cursor um 1 nach rechts */
  252.       if(!w->_cursor_x && old_y == w->_width_y-1)  /* Wenn gescrollt wurde, dann in letzter Zeile */
  253.       {                 /* korrekten Teil der Eingabe anzeigen         */
  254.     *pos_first -= w->_width_x;  /* Erstes Zeichen eine Zeile weiter oben */
  255.     *pos_last  -= w->_width_x;
  256.     if(*pos_firsts > w->_image) /* Wo steht nun das erste sichtbare */
  257.     {                         /* Zeichen der Eingabe ?            */
  258.       *pos_firsts -= w->_width_x;
  259.       if(*pos_firsts < w->_image)
  260.         *pos_firsts = w->_image;
  261.     }
  262.     *buff_first = buffer + (*pos_firsts - *pos_first);
  263.     inp_out(w,old_pos,buff_last,pos_lasts);
  264.     wrefresh(w);
  265.       }
  266.       else
  267.     place_cursor(w);
  268.     }
  269.   }
  270. }
  271.  
  272. /******************************************************************************
  273. *
  274. * Funktion     : Zeichen in Eingabe löschen (edit_del)
  275. * --------------
  276. *
  277. * Parameter    : w           :
  278. *                  Typ          : WINDOW *
  279. *                  Wertebereich : Pointer auf WINDOW-Struktur
  280. *                  Bedeutung    : Fenster, in dem evtl. Cursor bewegt werden
  281. *                                 soll
  282. *
  283. *              : buff_last   :
  284. *                  Typ          : char **
  285. *                  Wertebereich : Doppelpointer auf Zeichen in buffer
  286. *                  Bedeutung    : Letztes sichtbares Zeichen in buffer
  287. *
  288. *              : pos_last    :
  289. *                  Typ          : short int **
  290. *                  Wertebereich : Doppelpointer in Window-Image
  291. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  292. *                                 theoretisch das letzte Zeichen der Eingabe
  293. *                                 stehen würde (kann hinters image zeigen)
  294. *
  295. *              : pos_lasts   :
  296. *                  Typ          : short int **
  297. *                  Wertebereich : Doppelpointer in Window-Image
  298. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  299. *                                 das letzte sichtbare Zeichen der Eingabe
  300. *                                 steht.
  301. *
  302. *              : old_pos     :
  303. *                  Typ          : short int **
  304. *                  Wertebereich : Doppelpointer in Window-Image
  305. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, bis wo
  306. *                                 vor der letzten Ausgabe der Eingabe der
  307. *                                 Text auf dem Bildschirm ging.
  308. *
  309. * Beschreibung : Es wird zunächst getestet, ob sich der Cursor nicht am Ende
  310. *                des bisher eingegebenen Strings befindet. Ist dem so, dann
  311. *                geschieht nichts. Sonst wird, falls echoflag gesetzt ist, der
  312. *                Cursor um 1 nach rechts bewegt. Anschliessend wird p_in
  313. *                angepasst. Wurde durch die Cursorbewegung gescrollt, wird
  314. *                die nächste Zeile der Eingabe angezeigt und die Variablen
  315. *                buff_first etc. angepasst.
  316. *
  317. ******************************************************************************/
  318.  
  319. void edit_del(w,buff_last,pos_last,pos_lasts,old_pos)
  320. WINDOW *w;
  321. char **buff_last;
  322. short int **pos_last, **pos_lasts, **old_pos;
  323. {
  324.   if(*p_in) /* DEL geht nur, wenn man nicht hinter Eingabeende steht */
  325.   {
  326.     strcpy(p_in,p_in+1); /* Reststring 1 ranziehen */
  327.     if(echoflag)
  328.     {
  329.       (*pos_last)--;
  330.       inp_out(w,old_pos,buff_last,pos_lasts);
  331.       wrefresh(w);
  332.     }
  333.   }
  334. }
  335.  
  336. /******************************************************************************
  337. *
  338. * Funktion     : Testen ob Zeichen Worttrenner (wort_ende)
  339. * --------------
  340. *
  341. * Parameter    : c           :
  342. *                  Typ          : char
  343. *                  Wertebereich : '\0' - '\255'
  344. *                  Bedeutung    : zu testendes Zeichen
  345. *
  346. * Ergebnis     :
  347. *                  Typ          : char *
  348. *                  Wertebereich : NULL, ungleich NULL
  349. *                  Bedeutung    : NULL: Kein Worttrenner; ungleich NULL: Wort-
  350. *                                 trenner
  351. *
  352. * Beschreibung : Es wird mit der Funktion strchr getestet, ob sich das über-
  353. *                gebene Zeichen in dem String der Worttrenner befindet. Ist
  354. *                dem so, wird ein Pointer auf die entsprechende Stelle im
  355. *                String der Worttrenner zurückgegeben, sonst wird NULL zurück-
  356. *                gegeben.
  357. *
  358. ******************************************************************************/
  359.  
  360. char wort_ende(c)
  361. char c;
  362. {
  363.   return(strchr(" ,.;:#+-*[]{}|!$%&/\\()=?'`^\"",c));
  364. }
  365.  
  366. /******************************************************************************
  367. *
  368. * Funktion     : Cursor in Eingabe ein Wort nach rechts (edit_ctrlright)
  369. * --------------
  370. *
  371. * Parameter    : w           :
  372. *                  Typ          : WINDOW *
  373. *                  Wertebereich : Pointer auf WINDOW-Struktur
  374. *                  Bedeutung    : Fenster, in dem evtl. Cursor bewegt werden
  375. *                                 soll
  376. *
  377. *              : buff_first  :
  378. *                  Typ          : char **
  379. *                  Wertebereich : Doppelpointer auf Zeichen in buffer
  380. *                  Bedeutung    : Erstes sichtbares Zeichen in buffer
  381. *
  382. *              : buff_last   :
  383. *                  Typ          : char **
  384. *                  Wertebereich : Doppelpointer auf Zeichen in buffer
  385. *                  Bedeutung    : Letztes sichtbares Zeichen in buffer
  386. *
  387. *              : pos_first   :
  388. *                  Typ          : short int **
  389. *                  Wertebereich : Doppelpointer in Window-Image
  390. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  391. *                                 theoretisch das erste Zeichen der Eingabe
  392. *                                 stehen würde (kann kleiner als image sein)
  393. *
  394. *              : pos_firsts  :
  395. *                  Typ          : short int **
  396. *                  Wertebereich : Doppelpointer in Window-Image
  397. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  398. *                                 das letzte sichtbare Zeichen der Eingabe
  399. *                                 steht.
  400. *
  401. *              : pos_lasts   :
  402. *                  Typ          : short int **
  403. *                  Wertebereich : Doppelpointer in Window-Image
  404. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  405. *                                 das letzte sichtbare Zeichen der Eingabe
  406. *                                 steht.
  407. *
  408. *              : old_pos     :
  409. *                  Typ          : short int **
  410. *                  Wertebereich : Doppelpointer in Window-Image
  411. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, bis wo
  412. *                                 vor der letzten Ausgabe der Eingabe der
  413. *                                 Text auf dem Bildschirm ging.
  414. *
  415. * Beschreibung : Es wird zunächst getestet, ob sich der Cursor nicht am Ende
  416. *                des bisher eingegebenen Strings befindet. Ist dem so, dann
  417. *                geschieht nichts. Sonst wird der Cursor mit der Funktion
  418. *                edit_right in der Eingabe um 1 nach rechts bewegt, wobei
  419. *                der Bildschirm und alle nötigen Variablen korrekt angepasst
  420. *                werden. Das wird sooft wiederholt, bis das Zeichen links
  421. *                vom Cursor ein Worttrenner ist.
  422. *
  423. ******************************************************************************/
  424.  
  425. void edit_ctrlright(w,buff_first,buff_last,pos_first,pos_firsts,pos_last,pos_lasts,old_pos)
  426. WINDOW *w;
  427. char **buff_first,**buff_last;
  428. short int **pos_first, **pos_firsts, **pos_last, **pos_lasts, **old_pos;
  429. {
  430.   if(*p_in)
  431.     do
  432.       edit_right(w,buff_first,buff_last,pos_first,pos_firsts,pos_last,pos_lasts,old_pos);
  433.     while(*p_in && !wort_ende(p_in[-1]));
  434. }
  435.  
  436. /******************************************************************************
  437. *
  438. * Funktion     : Cursor in Eingabe ein Wort nach links (edit_ctrlleft)
  439. * --------------
  440. *
  441. * Parameter    : w           :
  442. *                  Typ          : WINDOW *
  443. *                  Wertebereich : Pointer auf WINDOW-Struktur
  444. *                  Bedeutung    : Fenster, in dem evtl. Cursor bewegt werden
  445. *                                 soll
  446. *
  447. *              : buff_first  :
  448. *                  Typ          : char **
  449. *                  Wertebereich : Doppelpointer auf Zeichen in buffer
  450. *                  Bedeutung    : Erstes sichtbares Zeichen in buffer
  451. *
  452. *              : buff_last   :
  453. *                  Typ          : char **
  454. *                  Wertebereich : Doppelpointer auf Zeichen in buffer
  455. *                  Bedeutung    : Letztes sichtbares Zeichen in buffer
  456. *
  457. *              : pos_first   :
  458. *                  Typ          : short int **
  459. *                  Wertebereich : Doppelpointer in Window-Image
  460. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  461. *                                 theoretisch das erste Zeichen der Eingabe
  462. *                                 stehen würde (kann kleiner als image sein)
  463. *
  464. *              : pos_last    :
  465. *                  Typ          : short int **
  466. *                  Wertebereich : Doppelpointer in Window-Image
  467. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  468. *                                 theoretisch das letzte Zeichen der Eingabe
  469. *                                 stehen würde (kann hinters image zeigen)
  470. *
  471. *              : pos_lasts   :
  472. *                  Typ          : short int **
  473. *                  Wertebereich : Doppelpointer in Window-Image
  474. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  475. *                                 das letzte sichtbare Zeichen der Eingabe
  476. *                                 steht.
  477. *
  478. *              : old_pos     :
  479. *                  Typ          : short int **
  480. *                  Wertebereich : Doppelpointer in Window-Image
  481. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, bis wo
  482. *                                 vor der letzten Ausgabe der Eingabe der
  483. *                                 Text auf dem Bildschirm ging.
  484. *
  485. * Beschreibung : Es wird zunächst getestet, ob man nicht schon am Anfang der
  486. *                Eingabe steht. Ist dem so, geschieht nichts. Sonst wird über
  487. *                die Funktion edit_left der Cursor so oft (mindestens 1 mal)
  488. *                nach links bewegt, bis das Zeichen links vom Cursor ein
  489. *                Worttrenner ist. Dabei werden alle wichtigen Variablen und
  490. *                der Bildschirm von der Funktion edit_left korrekt angepasst.
  491. *
  492. ******************************************************************************/
  493.  
  494. void edit_ctrlleft(w,buff_first,buff_last,pos_first,pos_last,pos_lasts,old_pos)
  495. WINDOW *w;
  496. char **buff_first,**buff_last;
  497. short int **pos_first, **pos_last, **pos_lasts, **old_pos;
  498. {
  499.   if(p_in > buffer)
  500.     do
  501.       edit_left(w,buff_first,buff_last,pos_first,pos_last,pos_lasts,old_pos);
  502.     while(p_in > buffer && !wort_ende(p_in[-1]));
  503. }
  504.  
  505. /******************************************************************************
  506. *
  507. * Funktion     : Cursor an Eingabeanfang (edit_home)
  508. * --------------
  509. *
  510. * Parameter    : w           :
  511. *                  Typ          : WINDOW *
  512. *                  Wertebereich : Pointer auf WINDOW-Struktur
  513. *                  Bedeutung    : Fenster, in dem evtl. Cursor bewegt werden
  514. *                                 soll
  515. *
  516. *              : buff_first  :
  517. *                  Typ          : char **
  518. *                  Wertebereich : Doppelpointer auf Zeichen in buffer
  519. *                  Bedeutung    : Erstes sichtbares Zeichen in buffer
  520. *
  521. *              : buff_last   :
  522. *                  Typ          : char **
  523. *                  Wertebereich : Doppelpointer auf Zeichen in buffer
  524. *                  Bedeutung    : Letztes sichtbares Zeichen in buffer
  525. *
  526. *              : pos_first   :
  527. *                  Typ          : short int **
  528. *                  Wertebereich : Doppelpointer in Window-Image
  529. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  530. *                                 theoretisch das erste Zeichen der Eingabe
  531. *                                 stehen würde (kann kleiner als image sein)
  532. *
  533. *              : pos_firsts  :
  534. *                  Typ          : short int **
  535. *                  Wertebereich : Doppelpointer in Window-Image
  536. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  537. *                                 das letzte sichtbare Zeichen der Eingabe
  538. *                                 steht.
  539. *
  540. *              : pos_last    :
  541. *                  Typ          : short int **
  542. *                  Wertebereich : Doppelpointer in Window-Image
  543. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  544. *                                 theoretisch das letzte Zeichen der Eingabe
  545. *                                 stehen würde (kann hinters image zeigen)
  546. *
  547. *              : pos_lasts   :
  548. *                  Typ          : short int **
  549. *                  Wertebereich : Doppelpointer in Window-Image
  550. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  551. *                                 das letzte sichtbare Zeichen der Eingabe
  552. *                                 steht.
  553. *
  554. *              : old_pos     :
  555. *                  Typ          : short int **
  556. *                  Wertebereich : Doppelpointer in Window-Image
  557. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, bis wo
  558. *                                 vor der letzten Ausgabe der Eingabe der
  559. *                                 Text auf dem Bildschirm ging.
  560. *
  561. * Beschreibung : Die Variable p_in wird auf buffer gesetzt. Liegt das erste
  562. *                Zeichen der Eingabe momentan auaerhalb des Bildschirms, so
  563. *                wird der String ab der linken oberen Bildschirmecke erneut
  564. *                angezeigt und die Variablen buff_first etc. werden angepasst.
  565. *
  566. ******************************************************************************/
  567.  
  568. void edit_home(w,buff_first,buff_last,pos_first,pos_firsts,pos_last,pos_lasts,old_pos)
  569. WINDOW *w;
  570. char **buff_first,**buff_last;
  571. short int  **pos_first, **pos_firsts, **pos_last, **pos_lasts, **old_pos;
  572. {
  573.   p_in = buffer;
  574.   if(echoflag)
  575.   {
  576.     if(*pos_first < *pos_firsts)
  577.     {
  578.       *pos_first = *pos_firsts = w->_image;
  579.       *pos_last = *pos_first + strlen(buffer);
  580.       *buff_first = buffer;
  581.       wmove(w,0,0);
  582.       inp_out(w,old_pos,buff_last,pos_lasts);
  583.       wrefresh(w);
  584.     }
  585.     else
  586.     {
  587.       poi_to_cur(w,*pos_first);
  588.       place_cursor(w);
  589.     }
  590.   }
  591. }
  592.  
  593. /******************************************************************************
  594. *
  595. * Funktion     : Cursor an Eingabeende (edit_end)
  596. * --------------
  597. *
  598. * Parameter    : w           :
  599. *                  Typ          : WINDOW *
  600. *                  Wertebereich : Pointer auf WINDOW-Struktur
  601. *                  Bedeutung    : Fenster, in dem evtl. Cursor bewegt werden
  602. *                                 soll
  603. *
  604. *              : buff_first  :
  605. *                  Typ          : char **
  606. *                  Wertebereich : Doppelpointer auf Zeichen in buffer
  607. *                  Bedeutung    : Erstes sichtbares Zeichen in buffer
  608. *
  609. *              : buff_last   :
  610. *                  Typ          : char **
  611. *                  Wertebereich : Doppelpointer auf Zeichen in buffer
  612. *                  Bedeutung    : Letztes sichtbares Zeichen in buffer
  613. *
  614. *              : pos_first   :
  615. *                  Typ          : short int **
  616. *                  Wertebereich : Doppelpointer in Window-Image
  617. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  618. *                                 theoretisch das erste Zeichen der Eingabe
  619. *                                 stehen würde (kann kleiner als image sein)
  620. *
  621. *              : pos_firsts  :
  622. *                  Typ          : short int **
  623. *                  Wertebereich : Doppelpointer in Window-Image
  624. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  625. *                                 das letzte sichtbare Zeichen der Eingabe
  626. *                                 steht.
  627. *
  628. *              : pos_last    :
  629. *                  Typ          : short int **
  630. *                  Wertebereich : Doppelpointer in Window-Image
  631. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  632. *                                 theoretisch das letzte Zeichen der Eingabe
  633. *                                 stehen würde (kann hinters image zeigen)
  634. *
  635. *              : pos_lasts   :
  636. *                  Typ          : short int **
  637. *                  Wertebereich : Doppelpointer in Window-Image
  638. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  639. *                                 das letzte sichtbare Zeichen der Eingabe
  640. *                                 steht.
  641. *
  642. * Beschreibung : Falls eingegebene Zeichen angezeigt werden, wird der String
  643. *                ab der Position, wo der Cursor steht, angezeigt. Dadurch
  644. *                steht danach auf dem Bildschirm der Cursor schon an der
  645. *                richtigen Stelle. Alle Variablen (pos_first etc.) werden
  646. *                angepasst. p_in wird an das Ende des in buffer enthaltenen
  647. *                Strings gesetzt.
  648. *
  649. ******************************************************************************/
  650.  
  651. void edit_end(w,buff_first,buff_last,pos_first,pos_firsts,pos_last,pos_lasts)
  652. WINDOW *w;
  653. char **buff_first,**buff_last;
  654. short int  **pos_first, **pos_firsts, **pos_last, **pos_lasts;
  655. {
  656.   int len = strlen(buffer);
  657.  
  658.   if(echoflag)
  659.   {
  660.     waddstr(w,p_in);
  661.     wrefresh(w);
  662.     *pos_last = *pos_lasts = cur_to_poi(w);
  663.     *pos_first = *pos_firsts = *pos_last-len;
  664.     if(*pos_firsts < w->_image)
  665.       *pos_firsts = w->_image;
  666.     *buff_first = buffer + (*pos_firsts - *pos_first);
  667.   }
  668.   *buff_last = p_in = buffer + len; /* p_in auf terminierende 0 setzen */
  669. }
  670.  
  671. /******************************************************************************
  672. *
  673. * Funktion     : Edit-Tasten behandeln (treat_edit_keys)
  674. * --------------
  675. *
  676. * Parameter    : w           :
  677. *                  Typ          : WINDOW *
  678. *                  Wertebereich : Pointer auf WINDOW-Struktur
  679. *                  Bedeutung    : Fenster, in dem evtl. Cursor bewegt werden
  680. *                                 soll
  681. *
  682. *              : insert      :
  683. *                  Typ          : char *
  684. *                  Wertebereich : Pointer auf Character-Variable
  685. *                  Bedeutung    : Insert-Modus
  686. *
  687. *              : buff_first  :
  688. *                  Typ          : char **
  689. *                  Wertebereich : Doppelpointer auf Zeichen in buffer
  690. *                  Bedeutung    : Erstes sichtbares Zeichen in buffer
  691. *
  692. *              : buff_last   :
  693. *                  Typ          : char **
  694. *                  Wertebereich : Doppelpointer auf Zeichen in buffer
  695. *                  Bedeutung    : Letztes sichtbares Zeichen in buffer
  696. *
  697. *              : pos_first   :
  698. *                  Typ          : short int **
  699. *                  Wertebereich : Doppelpointer in Window-Image
  700. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  701. *                                 theoretisch das erste Zeichen der Eingabe
  702. *                                 stehen würde (kann kleiner als image sein)
  703. *
  704. *              : pos_firsts  :
  705. *                  Typ          : short int **
  706. *                  Wertebereich : Doppelpointer in Window-Image
  707. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  708. *                                 das letzte sichtbare Zeichen der Eingabe
  709. *                                 steht.
  710. *
  711. *              : pos_last    :
  712. *                  Typ          : short int **
  713. *                  Wertebereich : Doppelpointer in Window-Image
  714. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  715. *                                 theoretisch das letzte Zeichen der Eingabe
  716. *                                 stehen würde (kann hinters image zeigen)
  717. *
  718. *              : pos_lasts   :
  719. *                  Typ          : short int **
  720. *                  Wertebereich : Doppelpointer in Window-Image
  721. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  722. *                                 das letzte sichtbare Zeichen der Eingabe
  723. *                                 steht.
  724. *
  725. *              : old_pos     :
  726. *                  Typ          : short int **
  727. *                  Wertebereich : Doppelpointer in Window-Image
  728. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, bis wo
  729. *                                 vor der letzten Ausgabe der Eingabe der
  730. *                                 Text auf dem Bildschirm ging.
  731. *
  732. * Beschreibung : Diese Funktion wird von getch_cooked aufgerufen, wenn dort
  733. *                '\0' eingelesen wurde. Hier wird dann das folgende Zeichen
  734. *                eingelesen. Daraus ergibt sich normal eine Kontroll-Kombina-
  735. *                tion. Ist das der Fall, so wird eine Funktion aufgerufen,
  736. *                die die Kombination auswertet.
  737. *
  738. ******************************************************************************/
  739.  
  740. void treat_edit_keys(c,w,insert,buff_first,buff_last,pos_first,pos_firsts,pos_last,pos_lasts,old_pos)
  741. short int c;
  742. WINDOW *w;
  743. char   *insert,**buff_first,**buff_last;
  744. short int  **pos_first, **pos_firsts, **pos_last, **pos_lasts, **old_pos;
  745. {
  746.   int *pos; /* eee nur damit Syntax in Ordnung ist */
  747.  
  748. #ifdef OS2
  749.   switch(c)
  750. #else
  751.   switch(getch(TRUE)) /* warte auf Zeichen => TRUE */
  752. #endif
  753.   {
  754.     case KEY_LEFT : edit_left(w,buff_first,buff_last,pos_first,pos_last,pos_lasts,old_pos); break; /* Pfeil links */
  755.     case KEY_RIGHT: edit_right(w,buff_first,buff_last,pos_first,pos_firsts,pos_last,pos_lasts,old_pos); break; /* Pfeil rechts */
  756.     case KEY_INS  : *insert ^= TRUE;       break; /* Insert togglen */
  757.     case KEY_DEL  : edit_del(w,buff_last,pos_last,pos_lasts,old_pos); break; /* DEL */
  758.     case KEY_WORDL: edit_ctrlleft(w,buff_first,buff_last,pos_first,pos_last,pos_lasts,old_pos);  break; /* CTRL-Pfeil links */
  759.     case KEY_WORDR: edit_ctrlright(w,buff_first,buff_last,pos_first,pos_firsts,pos_last,pos_lasts,old_pos); break; /* CTRL-Pfeil rechts */
  760.     case KEY_HOME : edit_home(w,buff_first,buff_last,pos_first,pos_firsts,pos_last,pos_lasts,old_pos); break; /* HOME */
  761.     case KEY_END  : edit_end(w,buff_first,buff_last,pos_first,pos_firsts,pos_last,pos_lasts); break; /* END */
  762.   }
  763. }
  764.  
  765. /******************************************************************************
  766. *
  767. * Funktion     : Eingabe ausgeben (inp_out)
  768. * --------------
  769. *
  770. * Parameter    : w           :
  771. *                  Typ          : WINDOW *
  772. *                  Wertebereich : Pointer auf WINDOW-Struktur
  773. *                  Bedeutung    : Fenster, in dem Eingabe angezeigt werden
  774. *                                 soll
  775. *
  776. *              : old_pos     :
  777. *                  Typ          : short int **
  778. *                  Wertebereich : Pointer auf Pointer auf short int
  779. *                  Bedeutung    : Zeigt auf den Zeiger, der hinter das letzte
  780. *                                 Zeichen der Eingabe auf dem Bildschirm
  781. *                                 zeigt.
  782. *
  783. *              : buff_last   :
  784. *                  Typ          : char **
  785. *                  Wertebereich : Doppelpointer auf Zeichen in buffer
  786. *                  Bedeutung    : Letztes sichtbares Zeichen in buffer
  787. *
  788. *              : pos_lasts   :
  789. *                  Typ          : short int **
  790. *                  Wertebereich : Doppelpointer in Window-Image
  791. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  792. *                                 das letzte sichtbare Zeichen der Eingabe
  793. *                                 steht.
  794. *
  795. * Beschreibung : Die Eingabe wird ab der Position, an der der Cursor steht
  796. *                (p_in) ausgegeben. Sollte die auszugebende Eingabe über das
  797. *                Fensterende hinausgehen, so bricht die Ausgabe bei vollem
  798. *                Fenster ab.
  799. *                Falls dann der Cursor vor dem alten Ende der
  800. *                Eingabe steht, die Eingabe also kürzer geworden
  801. *                ist, wird der Rest der alten Eingabe auf dem Bildschirm
  802. *                gelöscht. Anschliessend wird der Cursor wieder auf seine
  803. *                alte Position gestellt. In der Variablen, auf die buff_last
  804. *                zeigt, wird vermerkt, wo das letzte angezeigte Zeichen im
  805. *                Eingabepuffer steht. In der Variablen, auf die pos_lasts
  806. *                zeigt, wird eingetragen, wo das letzte angezeigte Zeichen
  807. *                auf dem Bildschirm steht.
  808. *
  809. ******************************************************************************/
  810.  
  811. void inp_out(w,old_pos,buff_last,pos_lasts)
  812. WINDOW *w;
  813. short int  **old_pos, **pos_lasts;
  814. char **buff_last;
  815. {
  816.   short int  *help_pos, *new_pos;
  817.   int       old_x = w->_cursor_x,old_y = w->_cursor_y;
  818.   char      old_scroll = w->_scrflag,*p_in1 = p_in;
  819.  
  820.   w->_scrflag = FALSE; /* Kein Scrolling, damit letzte Zeile ganz genutzt wird */
  821.   while(*p_in1 && (w->_cursor_y < w->_width_y-1 || w->_cursor_x < w->_width_x-1))
  822.     waddch(w,*p_in1++);
  823.   *buff_last = p_in1-1;
  824.   *pos_lasts = cur_to_poi(w)-1;
  825.   if(*p_in1)         /* Brach WHILE ab, weil Fenster voll ? */
  826.   {
  827.     *old_pos = cur_to_poi(w)+1;
  828.     (*buff_last)++;
  829.     (*pos_lasts)++;
  830.     waddch(w,*p_in1); /* Ja, dann letztes Zeichen anzeigen   */
  831.   }
  832.   else
  833.   {
  834.     /* Falls neue Eingabe kürzer, Rest der alten löschen */
  835.     for(help_pos = new_pos = cur_to_poi(w) ; help_pos < *old_pos ; help_pos++)
  836.       *help_pos = STD_ATTR*256;
  837.     *old_pos = new_pos;
  838.   }
  839.   wmove(w,old_y,old_x);
  840.   w->_scrflag = old_scroll;
  841. }
  842.  
  843. /******************************************************************************
  844. *
  845. * Funktion     : Backspace beim Edieren behandeln (treat_backspace)
  846. * --------------
  847. *
  848. * Parameter    : w           :
  849. *                  Typ          : WINDOW *
  850. *                  Wertebereich : Pointer auf WINDOW-Struktur
  851. *                  Bedeutung    : Fenster, in dem evtl. Cursor bewegt werden
  852. *                                 soll
  853. *
  854. *              : buff_first  :
  855. *                  Typ          : char **
  856. *                  Wertebereich : Doppelpointer auf Zeichen in buffer
  857. *                  Bedeutung    : Erstes sichtbares Zeichen in buffer
  858. *
  859. *              : buff_last   :
  860. *                  Typ          : char **
  861. *                  Wertebereich : Doppelpointer auf Zeichen in buffer
  862. *                  Bedeutung    : Letztes sichtbares Zeichen in buffer
  863. *
  864. *              : pos_first   :
  865. *                  Typ          : short int **
  866. *                  Wertebereich : Doppelpointer in Window-Image
  867. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  868. *                                 theoretisch das erste Zeichen der Eingabe
  869. *                                 stehen würde (kann kleiner als image sein)
  870. *
  871. *              : pos_last    :
  872. *                  Typ          : short int **
  873. *                  Wertebereich : Doppelpointer in Window-Image
  874. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  875. *                                 theoretisch das letzte Zeichen der Eingabe
  876. *                                 stehen würde (kann hinters image zeigen)
  877. *
  878. *              : pos_lasts   :
  879. *                  Typ          : short int **
  880. *                  Wertebereich : Doppelpointer in Window-Image
  881. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, wo
  882. *                                 das letzte sichtbare Zeichen der Eingabe
  883. *                                 steht.
  884. *
  885. *              : old_pos     :
  886. *                  Typ          : short int **
  887. *                  Wertebereich : Doppelpointer in Window-Image
  888. *                  Bedeutung    : Zeigt auf die Stelle im Window-Image, bis wo
  889. *                                 vor der letzten Ausgabe der Eingabe der
  890. *                                 Text auf dem Bildschirm ging.
  891. *
  892. * Beschreibung : Falls möglich, werden alle Zeichen ab der Cursorposition
  893. *                um eine Position im Eingabepuffer nach vorne gezogen. p_in
  894. *                wird dekrementiert. Im Normalfall wird dann über waddch das
  895. *                Backspace ausgegeben, und anschlieaend der Reststring aus-
  896. *                gegeben. Wurde jedoch ein nicht auf dem Bildschirm stehendes
  897. *                Zeichen gelöscht, werden nur buff_first und pos_first ange-
  898. *                passt.
  899. *
  900. ******************************************************************************/
  901.  
  902. void treat_backspace(w,buff_first,buff_last,pos_first,pos_last,pos_lasts,old_pos)
  903. WINDOW *w;
  904. char **buff_first,**buff_last;
  905. short int  **pos_first, **pos_last, **pos_lasts, **old_pos;
  906. {
  907.   if(p_in > buffer)  /* Falls noch ein Zeichen im Puffer, dieses löschen */
  908.   {
  909.     strcpy(p_in-1,p_in); /* Reststring 1 ranziehen */
  910.     p_in--;
  911.     if(echoflag) /* Falls echo gesetzt, Zeichen auch auf dem Bildschirm löschen */
  912.       if(p_in>=*buff_first) /* Falls nicht vor erstem sichtbaren Zeichen gelöscht wurde */
  913.       {
  914.     waddch(w,'\b'); /* ein Zeichen löschen */
  915.     (*pos_last)--;
  916.     inp_out(w,old_pos,buff_last,pos_lasts);
  917.     wrefresh(w);
  918.       }
  919.       else
  920.       {
  921.     *buff_first = p_in; /* Jetzt kann man schon ein früheres Zeichen sehen */
  922.     (*pos_first)++;     /* Stringanfang rückt eins auf */
  923.       }
  924.   }
  925. }
  926.  
  927. /******************************************************************************
  928. *
  929. * Funktion     : Ein Zeichen in Puffer einfügen (buf_insert)
  930. * --------------
  931. *
  932. * Beschreibung : In buffer werden alle Zeichen ab p_in um eins nach rechts
  933. *                geschoben, falls dafür noch Platz ist.
  934. *
  935. ******************************************************************************/
  936.  
  937. void buf_insert()
  938. {
  939.   char buff[BUFF_SIZE+1];
  940.  
  941.   if(strlen(buffer) == BUFF_SIZE)
  942.     fatal("Eingabepuffer voll, kann kein Zeichen mehr einfügen");
  943.   strcpy(buff,p_in);
  944.   strcpy(p_in+1,buff);
  945. }
  946.  
  947. /******************************************************************************
  948. *
  949. * Funktion     : Zeichen gepuffert einlesen (getch_cooked)
  950. * --------------
  951. *
  952. * Parameter    : w           :
  953. *                  Typ          : WINDOW *
  954. *                  Wertebereich : Pointer auf WINDOW-Struktur
  955. *                  Bedeutung    : Fenster, in dem gelesene Zeichen evtl. an-
  956. *                                 gezeigt werden sollen.
  957. *
  958. * Ergebnis     :
  959. *                  Typ          : char
  960. *                  Wertebereich : '\0' - '\255'
  961. *                  Bedeutung    : Eingelesenes Zeichen
  962. *
  963. * Beschreibung : Falls noch ein Zeichen im Eingabepuffer ist, wird es direkt
  964. *                zurückgegeben. Sonst wird eine Zeile eingelesen, die mit
  965. *                RETURN abgeschlossen werden mua. Die Zeile darf ediert werden.
  966. *                Alle eingelesenen Zeichen werden in einen Puffer geschrieben,
  967. *                aus dem sie hinterher in der Reihenfolge ihrer Eingabe wieder
  968. *                ausgelesen werden können. Es wird dann das erste Zeichen des
  969. *                Puffers zurückgegeben.
  970. *
  971. ******************************************************************************/
  972.  
  973. char getch_cooked(w)
  974. WINDOW *w;
  975. {
  976.   short int c,old_tab = w->_tabflag,insert=FALSE;
  977.   char *buff_first,*buff_last;
  978.   short int  *pos_first, *pos_last, *pos_firsts, *pos_lasts;
  979.   int  i;
  980.   short int old_y,*old_pos;
  981.  
  982.   if(p_in != p_out) /* Falls noch ein Zeichen im Puffer, dieses zurückgeben */
  983.     return(*p_out++);
  984.   p_in = p_out = buff_first = buff_last = buffer; /* p_in statt auf Pufferende jetzt wieder auf Pufferanfang */
  985.   pos_first = pos_last = pos_firsts = pos_lasts = old_pos = cur_to_poi(w);
  986.   for(i=0 ; i<BUFF_SIZE ; i++)
  987.     buffer[i]='\0';   /* Dadurch kann String-Ende leicht gefunden werden */
  988.   w->_tabflag = FALSE; /* Tabs nicht zu Spaces expandieren */
  989.   do
  990.   {
  991.     c = getch(TRUE); /* Warte auf Zeichen => TRUE */
  992.     switch(c % 256) /* Low-Byte des gelesenen Zeichens betrachten */
  993.     {
  994.       case '\0':    /* Sonderfunktion, dann ist Low-Byte 0 */
  995.     treat_edit_keys(c,w,&insert,&buff_first,&buff_last,&pos_first,&pos_firsts,&pos_last,&pos_lasts,&old_pos); /* Sondertaste lesen und evtl. ausführen */
  996.     break;
  997.       case '\b':           /* Backspace */
  998.     treat_backspace(w,&buff_first,&buff_last,&pos_first,&pos_last,&pos_lasts,&old_pos);
  999.     break;
  1000.       case '\r':           /* CR als CR-LF anzeigen aber als CR eintragen */
  1001.     if(echoflag)       /* Wird dann evtl. von wgetch in NL umgewandelt */
  1002.       waddstr(w,p_in); /* Cursor an Eingabeende bringen */
  1003.     p_in = buffer+strlen(buffer); /* '\r' immer am Ende anhängen */
  1004.     *p_in++ = (char) (c % 256); /* Zeichen aus dem Tastaturcode extrahieren */
  1005.     if(echoflag)
  1006.     {
  1007.       waddstr(w,"\n\r");
  1008.       wrefresh(w);
  1009.     }
  1010.     break;
  1011.       default:             /* Jedes andere Zeichen */
  1012.     if(insert)
  1013.     {
  1014.       buf_insert();    /* Evtl. ein Zeichen in Puffer einfügen */
  1015.       pos_last++;
  1016.     }
  1017.     *p_in++ = (char) (c % 256);       /* in Puffer eintragen */
  1018.     if(echoflag)
  1019.     {
  1020.       old_y = w->_cursor_y;
  1021.       waddch(w,c % 256);     /* Zeichen falls echo gesetzt ist auf dem Bildschirm anzeigen */
  1022.       if(!w->_cursor_x && old_y == w->_width_y-1) /* Wurde gescrollt ? */
  1023.       {
  1024.         pos_first -= w->_width_x; /* Erstes Zeichen eine Zeile weiter oben */
  1025.         if(pos_firsts > w->_image) /* Wo steht nun das erste sichtbare */
  1026.         {                         /* Zeichen der Eingabe ?            */
  1027.           pos_firsts -= w->_width_x;
  1028.           if(pos_firsts < w->_image)
  1029.         pos_firsts = w->_image;
  1030.         }
  1031.         buff_first = buffer + (pos_firsts - pos_first);
  1032.       }
  1033.       inp_out(w,&old_pos,&buff_last,&pos_lasts); /* Rest der Eingabe anzeigen */
  1034.       wrefresh(w);
  1035.     }
  1036.     }
  1037.   } while (c != '\r' && p_in < buffer+BUFF_SIZE);
  1038.   w->_tabflag = old_tab;
  1039.   if(p_in >= buffer+BUFF_SIZE)
  1040.     fatal("Eingabepuffer voll!");
  1041.   return(*p_out++);     /* Erstes Zeichen aus dem Puffer zurückgeben */
  1042. }
  1043.  
  1044. /******************************************************************************
  1045. *
  1046. * Funktion     : Zeichen einlesen (wgetch)
  1047. * --------------
  1048. *
  1049. * Parameter    : w           :
  1050. *                  Typ          : WINDOW *
  1051. *                  Wertebereich : Pointer auf WINDOW-Struktur
  1052. *                  Bedeutung    : Fenster, in dem eingelesenes Zeichen evtl.
  1053. *                                 angezeigt werden soll.
  1054. *
  1055. * Ergebnis     :
  1056. *                  Typ          : short int
  1057. *                  Wertebereich : '\0' - '\255'
  1058. *                  Bedeutung    : Eingelesenes Zeichen
  1059. *
  1060. * Beschreibung : Falls delay FALSE ist, wird zunächst getestet, ob ein
  1061. *                Zeichen eingegeben wurde oder noch eins im Puffer steht.
  1062. *                Wenn nein, wird -1 zurückgegeben.
  1063. *                Sonst wird, auch wenn delay TRUE ist, ein Zeichen gelesen,
  1064. *                abhängig von raw entweder mit der Funktion getch oder
  1065. *                getch_cooked. Ist echo und raw gesetzt, wird
  1066. *                anschliessend das eingelesene Zeichen mit waddch angezeigt.
  1067. *                getch_cooked zeigt die Zeichen bei gesetztem echo selber an.
  1068. *
  1069. ******************************************************************************/
  1070.  
  1071. short int wgetch(w)
  1072. WINDOW *w;
  1073. {
  1074.   short int c = '\0';
  1075.  
  1076.   /* Aufruf von getch: warte nicht auf Zeichen => FALSE */
  1077.   if(!w->_dlyflag && p_in==p_out &&
  1078. #ifdef OS2
  1079.      !(c = getch (FALSE)))
  1080. #else
  1081.      !kbhit())
  1082. #endif
  1083.     return(-1);
  1084.   else
  1085.   {
  1086.     if(p_in != p_out) /* Falls noch ein Zeichen im Puffer, dieses zurückgeben */
  1087.       return(*p_out++);
  1088.     if(echoflag)  /* Falls eingegebene Zeichen angezeigt werden sollen, */
  1089.       place_cursor(w); /* Cursor an die richtige Stelle plazieren */
  1090.     if (!c) /* Wurde bei Test, ob Zeichen im Puffer, schon eins gelesen ? */
  1091.       c = rawflag ? getch(TRUE) : (short int) getch_cooked(w);
  1092.     if(c=='\r' && nlflag) /* Falls getch '\r' zurückliefert und das */
  1093.       c = '\n'; /* nlflag gesetzt ist, so soll doch '\n' zurückgegeben werden */
  1094.     if(echoflag && rawflag)
  1095.     {
  1096.       waddch(w,c);
  1097.       wrefresh(w);
  1098.     }
  1099.   }
  1100.   return(c);
  1101. }
  1102.